Android Overview

Marko Gargenta @MarkoGargenta

About Marko Gargenta

Entrepreneur, Author, Speaker

• Developer of Android Bootcamp for Marakana.
• Instructor for 1,000s of developers on Android at Qualcomm, Cisco, Motorola, Intel, DoD and other great orgs.
• Author of Learning Android published by O’Reilly.
• Speaker at OSCON (3x), ACM, IEEE, SDC, AnDevCon. Co-Founder of SFAndroid.org
• Co-Chair of Android Open conference: Android Open

Objectives of Android Overview

Android™ Overview course is designed to give you a high level overview of the entire Android platform. It is our gentle introduction to what Android operating system is, how we got here, what makes it fundamentally different than any other platform, and how to take advantage of its uniqueness. Android Overview is designed for both technical managers seeking high-level understanding of the platform as well as developers warming up for a deep dive into programming for Android. By the end of this course, you will have a complete understanding of the entire operating system, at a light level.

Topics in this course include:

• History of Android: How we got here, and where we may be heading
• Android Stack: The big picture overview of entire Android OS
• Hello, Android: Dissecting an Android app to understand all the moving parts
• Architecting Android Apps: Understanding main building blocks of an Android app
• Debugging and Testing: Tools that are available to you
• Android Security: An overview of how Android security model works

History of Android

   Objectives for History of Android

History of Android module focuses on how we got here. The goal of the module is to give us an idea of design philosophy behind Android, and what it may say about the future of the platform. At this high level, we explore both technical and business choices that effect the platform for a long time.

Topics in this module include:

• Vision for Android
• History overview
• Android versions
• Android add-ons
• Android fragmentation

   Vision for Android

Eric Schmidt

Our goal is not just a single device. Our vision is a mobile platform that runs on many many different devices. – Eric Schmidt

   Quick Overview of History

   Platform Versions

   Android OS Add-Ons

Android Add-Ons

   "With Google" Add-On

With Google

Devices that have “With Google” add-on feature a set of Google’s proprietary applications, such as Google Play (aka Android Market), Google Maps, Gmail, Gtalk, and many others.

OEMs and carriers typically enter into a licensing agreement with Google in order to distribute Google version of Android.

   Android Fragmentation?

Android Compatibility Test Suite: Defines “Android Compatible” Prevents incompatible releases Provides self testing

Fragmentations lines include:

• Versions of Android
• Add-ons by OEMs/Carriers
• Device capabilities

Best practices in app development eliminate these issues. CTS ensures compliance.

   Quiz

1. What year did Google acquire Android, Inc.?

2. What is the vision for Android?

3. What does API Level stand for?

4. What is the most current API level?

5. How do you find out the differences between various Android APIs?

   Summary of Android History

The goal of this module was to introduce you to how we got here.

By now, you should know about:

• Vision for Android
• History overview
• Android versions
• Android add-ons
• Android fragmentation

Android Stack

   Android Stack Objectives

The Android technology stack can be divided into four layers. This module provides an overview of each layer and the role it plays in the Android platform.

Topics in this module include:

• Design philosophy
• Open Source licenses
• Linux kernel space
• Native layer
• Dalvik VM
• Application layer
• Apps

   Design Philosophy: Why is Android put together the way it is?

Design and Engineering

Mobile platform that runs on many different devices needs to be friendly for the entire ecosystem.

That includes:

• Device manufacturers
• Network carriers
• App developers
• End users

   Not All Open Source is Created Equal

Open Source

Open source implies availability of source code, not the right to reuse it or modify it.

   Open Source Licenses

Open Source Licenses

   Android Stack - The Big Picture

Android Stack

   Android Stack - The Details

Android Stack Details

   Linux Kernel Space

Android Stack: Linux Kernel Layer

Android is based on a modified Linux kernel, which provides features such as:

• A permission-based security model
• Memory management
• Process management
• A network stack
• A device driver model

   Native Layer

Android Stack: Native Layer

The Android native layer contains:

• A custom libc implementation called Bionic
• Custom libraries for Android features
• Third-party open-source libraries such as WebKit, SQLite, OpenGL, etc.
• Linux daemons managing system features such as telephony, networking, sensors, etc.
• Auxiliary Linux executables

Android exposes only a small subset of native libraries to application developers through Android’s Native Development Kit (NDK).

   Dalvik Virtual Machine

Dalvik versus Java

Android applications execute in a Dalvik virtual machine (VM).

• The Dalvik VM was custom designed for the Android environment; it is not based on the Java VM.
• The Dalvik VM executes files in the Dalvik Executable (.dex) format.
• Each application process hosts its own Dalvik VM, ensuring strict sandboxing of applications.

Android supports Java as the primary application development language.

• The Android SDK includes the dx tool, which compiles Java bytecode to Dalvik bytecode.
• The Android Development Tool (ADT) plugin to Eclipse is pre-configured to generate Dalvik bytecode from your Java source.

Dalvik license plate

   Application Layer

Android Stack: Application Framework

The application framework layer implements Android’s Java language API for application development. It includes:

• Classes for implementing application components
• "Manager" classes for accessing Android system services such as Bluetooth, cameras, sensors, WiFi, etc.
• "Wrapper" classes for native libraries such as OpenGL and SQLite
• Most standard Java SE packages
• Auxiliary packages such as JSON and XML parsers and the Apache HTTP Client

   Apps

Android Stack: Applications

The application layer consists of pre-installed system applications and user-installed applications.

• System and user-installed applications have the same structure and are built on the same application framework layer.
• System applications have access to some private framework APIs not exposed to third-party application developers.
• System applications can’t be uninstalled by the user.

   Application Structure

You distribute an Android application as a single file, known as an application package or APK, containing:

• Dalvik executable code compiled from your Java source code
• Resources, such as images, audio/video clips, as well as numerous XML files describing layouts, language packs, and so on
• Optional native shared libraries, compiled from C/C++ source code using Android’s NDK.

APKs must be signed with a security certificate before they can be installed on a device.

• During development, you’ll use an automatically-generated debug certificate.
• For production, you’ll use a self-signed certificate that you generate.

  Google recommends a validity period of at least 25 years.

User-installed applications can provide the same functionality as most system applications.

• For example, there are several third-party browser applications available.
• Android allows the user to select one of these "replacement" applications as a default for actions like viewing a web page or sending an email.

   Quiz

1. What are the major levels of the Android stack?

2. How is Android different than Ubuntu?

3. What is the license for Linux kernel?

4. How is Android Linux kernel different than mainline kernel?

5. What are some of the components that go into the native layer?

6. What is Dalvik and how is it different than JVM?

7. What are the components of the Android framework?

8. What does API level specify in the context of the stack?

9. What is the difference between system and user apps?

   Summary of Android Stack

The goal of this module was to provide high level overview of the entire Android OS.

By now, you should be able to explain significance and purpose of:

• Linux kernel space
• Native layer
• Dalvik VM
• Application layer
• Apps

Hello, World!

   Objectives of Hello, World

The goal of this module is to have you write a simple Hello, World application. By the end of this module, you should be able to identify main parts of an app. You should also be able to verify that your tools are setup properly and that you can run the application on an Android device, either physical or emulated. Topics covered include:

• Android SDK: How to set it up and what it consists of
• About Eclipse: The power of the tools
• Creating a new Android project
• Anatomy of a project: What are all the moving parts
• Running the app: Emulator, real device, tools to monitor them both

   Android SDK

Android SDK Tools

Android SDK is all you need. Get it from d.android.com[http://developer.android.com/sdk/index.html] It is supported for Mac, Linux, or Windows. About equally.

You also need JDK.

And most people tend to use Eclipse[http://eclipse.org], a powerful and feature-rich tool.

   Create New Project

Create new project

Use the Eclipse tool to create a new Android project.

Here are some key constructs:

   Anatomy of An App

Anatomy of an app

Java Code + XML and Other Resources + Manifest File = Android App

   Run It!

Emulator

Android is agnostic to emulator versus a real device. For the most part.

Emulator is not a simulator!

Lately, for serious development, you may want to have a real device.

   Quiz

1. Where do you get the SDK from?

2. Once you download it and install the initial SDK, what next?

3. What are some of the main tools in the SDK?

4. What does ADT stand for, and where do you get it from?

5. What are three main parts of an app?

6. What is an Android APK?

7. What is the difference between an emulator and a simulator?

8. How do you run your app on a real device?

   Summary of Hello, World

The goal of this module was to create a simple Android app, to dissect it and analyze various parts that make up an app, and to build and run it on an Android device.

Architecting Android Apps Overview

   Architecting Android Apps Overview

The goal of this module is to introduce you to main components used to create Android apps. By the end of this module, you should have a good idea what Android app building blocks are, and their key properties.

Seven iterations of an app:

• Part 1 - Activities and Android UI
• Part 2 - Intents, Action Bar, and More
• Part 3 - Services
• Part 4 - Content Providers
• Part 5 - Lists and Adapters
• Part 6 - Broadcast Receivers
• Part 7 - App Widgets

   Yamba

Yamba

   Yamba Approach

   Part 1 - Activities and Android UI

Yamba Part 1

   Activity Overview

Example of Activities

• An activity is roughly a screen.
• A typical application may have many activities.
• Activities are typically expensive and so are managed by the system.

   Activity Lifecycle

Activity Lifecycle

• Activities are highly managed by the system’s ActivityManager.
• ActivityManager drives the activity through its states.
• You as an app developer get to say what happens on transitions.

   Activity Lifecycle Explored

D/ActivityDemo( 6708): onCreate
D/ActivityDemo( 6708): onStart
D/ActivityDemo( 6708): onResume

...
D/ActivityDemo( 6708): onClickAnotherActivity
D/ActivityDemo( 6708): onPause
D/ActivityDemo( 6708): onStop
D/ActivityDemo( 6708): onRestart
D/ActivityDemo( 6708): onStart
D/ActivityDemo( 6708): onResume

...
D/ActivityDemo( 6708): onPause
D/ActivityDemo( 6708): onStop
D/ActivityDemo( 6708): onDestroy
D/ActivityDemo( 6708): onCreate
D/ActivityDemo( 6708): onStart
D/ActivityDemo( 6708): onResume

...
D/ActivityDemo( 6708): onPause
D/ActivityDemo( 6708): onStop

...
D/ActivityDemo( 6708): onRestart
D/ActivityDemo( 6708): onStart
D/ActivityDemo( 6708): onResume

   Activity Template

package com.marakana.android.lifecycle;

import android.app.Activity;
import android.content.ContentValues;
import android.content.Intent;
import android.os.Bundle;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;

public class ActivityDemo extends Activity {
  static final String TAG = "ActivityDemo";

  // --- Lifecycle methods

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.main);
    Log.d(TAG, "onCreate");
  }

  @Override
  protected void onStart() {
    super.onStart();
    Log.d(TAG, "onStart");
  }

  @Override
  protected void onResume() {
    super.onResume();
    Log.d(TAG, "onResume");
  }

  @Override
  protected void onPause() {
    super.onPause();
    Log.d(TAG, "onPause");
  }

  @Override
  protected void onStop() {
    super.onStop();
    Log.d(TAG, "onStop");
  }

  @Override
  protected void onRestart() {
    super.onRestart();
    Log.d(TAG, "onRestart");
  }

  @Override
  protected void onDestroy() {
    super.onDestroy();
    Log.d(TAG, "onDestroy");
  }

  // --- Options menu methods

  @Override
  public boolean onCreateOptionsMenu(Menu menu) {
    getMenuInflater().inflate(R.menu.menu, menu);
    return true;
  }

  @Override
  public boolean onOptionsItemSelected(MenuItem item) {
    switch (item.getItemId()) {
    case R.id.item_start_service:
      startService(new Intent(this, ServiceDemo.class));
      return true;
    case R.id.item_stop_service:
      stopService(new Intent(this, ServiceDemo.class));
      return true;
    case R.id.item_refresh:
      startService(new Intent("marakana.intent.action.IntentServiceDemo"));
      return true;
    case R.id.item_send_broadcast:
      sendBroadcast(new Intent("marakana.intent.action.ReceiverDemo"));
      return true;
    case R.id.item_location:
      startActivity(new Intent(this, SystemServicesDemo.class));
      return true;
    case R.id.item_insert:
      getContentResolver()
          .insert(ProviderDemo.CONTENT_URI, new ContentValues());
      return true;
    case R.id.item_query:
      getContentResolver().query(ProviderDemo.CONTENT_URI, null, null, null,
          null);
      return true;
    }

    return false;
  }

  // --- Button click event handler

  public void onClickAnotherActivity(View v) {
    startActivity(new Intent(this, AnotherActivity.class));
    Log.d(TAG, "onClickAnotherActivity");
  }

}

   Activity Callbacks

   Registering Activity

...
<activity
  android:name=".ActivityDemo"
  android:label="@string/app_name">
  <intent-filter>
    <action android:name="android.intent.action.MAIN" />
    <category android:name="android.intent.category.LAUNCHER" />
  </intent-filter>
</activity>
...

...
<activity android:name=".AnotherActivity"></activity>
...

   Building Android UI

There are two approaches to building Android UI:

   Layouts and Views

Layouts and Views

   Part 2 - Intents, Action Bar, and More

Yamba Part 2

   Intent Overview

Example of Intents

• Intents are like events or messages.
• You can use them so start activities, start/stop services, or send broadcasts.
• Intents can be implicit or explicit.

   Using Intents

   Explicit and Implicit Intents

...
startActivity(new Intent(this, AnotherActivity.class));
...
startService(new Intent(this, ServiceDemo.class));
...

...
startService(new Intent("marakana.intent.action.IntentServiceDemo"));
...
sendBroadcast(new Intent("marakana.intent.action.ReceiverDemo"));
...

...
<service android:name=".IntentServiceDemo">
  <intent-filter>
    <action android:name="marakana.intent.action.IntentServiceDemo" />
  </intent-filter>
</service>
...
<receiver android:name=".ReceiverDemo">
  <intent-filter>
    <action android:name="marakana.intent.action.ReceiverDemo" />
  </intent-filter>
</receiver>
...

   Intent Filter

Intent filter is a way for us to assign certain action to an activity, service, receiver or similar.

Action is one of system defined actions, or something you come up with.

Intent filter typically goes into Android Manifest file, within <activity>, <service>, or <receiver> elements.

  ...
  <intent-filter>
    <action android:name="some.action.goes.here" />
  </intent-filter>
  ...

   Action Bar

The action bar, introduced in Honeycomb (API 11) is a title bar that includes:

• The application icon
• The activity title
• A set of user-selectable actions (optional)
• A set of user-selectable navigation modes (optional)

   Enabling the Action Bar

Android automatically displays an action bar on an API 11+ system if the <uses-sdk> element of your applications manifest:

• Sets minSdkVersion to 11 or later, or
• Sets targetSdkVersion to 11 or later

Either or these settings enable the "holographic look and feel" introduced in Honeycomb, which includes action bar support.

• If neither minSdkVersion nor targetSdkVersion are set to 11+, then an API 11+ system renders the app in a legacy theme, without action bar support.

With the action bar enabled, legacy option menu items appear automatically in the action bar’s overflow menu. You reveal the overflow menu with:

• The hardware Menu button (if present), or
• An additional button in the action bar (for devices without a hardware Menu button)

   Adding Action Items

To display an option menu item as an action item, in the menu resource file add android:showAsAction="ifRoom" to the <item> element.

• The device will display the item if there is room available in the action bar, otherwise the item appears in the overflow menu.
• Devices running API 10 or earlier ignore the showAsAction attribute.

If your menu item supplies both a title and an icon, the action item shows only the icon by default.

• To display the text title, add withText to the android:showAsAction attribute. For example:

<?xml version="1.0" encoding="utf-8"?>
<menu xmlns:android="http://schemas.android.com/apk/res/android">
    <item android:id="@+id/menu_save"
          android:icon="@drawable/ic_menu_save"
          android:title="@string/menu_save"
          android:showAsAction="ifRoom|withText" />
</menu>

The withText value is a hint to the action bar. The action bar will show the title if possible, but might not if an icon is available and the action bar is constrained for space.

   ICS Split Action Bars

API 14 introduced split action bar support.

• Enabling split action bar allows a device with a narrow screen to display a separate action bar at the bottom of the screen containing all action items.

You enable split action bar in the manifest add uiOptions="splitActionBarWhenNarrow":

• To an <activity> element to enable split action bar for that activity, or
• To the <application> element to enable split action bar for all activities

Devices on API 13 or earlier ignore the uiOptions attribute.

   Using the App Icon for Navigation

You can enable the application icon — which appears in the action bar on the left side — to behave as an action item. If enabled, your app should respond by:

• Going to the application "home" activity, or
• Navigating "up" the application’s structural hierarchy

When the user taps the app icon, the system calls your activity’s onOptionsItemSelected() method. The MenuItem passed as an argument has an ID of android.R.id.home.

The app icon was enabled by default in APIs 11-13. API 14 disables it be default. To enable it in API 14 or later: if (Build.VERSION.SDK_INT > Build.VERSION_CODES.ICE_CREAM_SANDWICH) { getActionBar().setHomeButtonEnabled(true); }

   Part 3 - Services

Yamba Part 3

   Service Overview

Example of a Service

• Services are code that runs in the background.
• They can be started and stopped. Services doesn’t have UI.
• Keep in mind that service runs on the main application thread, the UI thread.

   Service Lifecycle

Service Lifecycle

• Service starts and "runs" until it gets a request to stop.
• Service will run on the main UI thread.
• To offload work from main thread, use intent service.
• Intent service uses worker thread, stops when done with work.
• Services can be bound or unbound.

   Service Lifecycle Explored

D/ServiceDemo( 7623): onCreate
D/ServiceDemo( 7623): onStartCommand

...
D/ServiceDemo( 7623): onStartCommand

...
D/ServiceDemo( 7623): onDestroy

D/IntentServiceDemo( 7748): onCreate
D/IntentServiceDemo( 7748): onHandleIntent for action: marakana.intent.action.IntentServiceDemo
D/IntentServiceDemo( 7748): onDestroy

   Service Template

package com.marakana.android.lifecycle;

import android.app.Service;
import android.content.Intent;
import android.os.IBinder;
import android.util.Log;

public class ServiceDemo extends Service {
  static final String TAG = "ServiceDemo";

  @Override
  public IBinder onBind(Intent arg0) {
    return null;
  }

  @Override
  public void onCreate() {
    Log.d(TAG, "onCreate");
  }

  @Override
  public int onStartCommand(Intent intent, int flags, int startId) {
    Log.d(TAG, "onStartCommand");
    return  START_STICKY;
  }

  @Override
  public void onDestroy() {
    Log.d(TAG, "onDestroy");
  }

}

   IntentService Template

package com.marakana.android.lifecycle;

import android.app.IntentService;
import android.content.Intent;
import android.util.Log;

public class IntentServiceDemo extends IntentService {
  static final String TAG = "IntentServiceDemo";

  public IntentServiceDemo() {
    super(TAG);
  }

  @Override
  public void onCreate() {
    super.onCreate();
    Log.d(TAG, "onCreate");
  }

  @Override
  protected void onHandleIntent(Intent intent) {
    Log.d(TAG, "onHandleIntent for action: " + intent.getAction());
  }

  @Override
  public void onDestroy() {
    super.onDestroy();
    Log.d(TAG, "onDestroy");
  }

}

   Service Callbacks

   IntentService Callbacks

   Registering Service

...
<service android:name=".ServiceDemo"></service>
...

...
<service android:name=".IntentServiceDemo">
  <intent-filter>
    <action android:name="marakana.intent.action.IntentServiceDemo" />
  </intent-filter>
</service>
...

   Part 4 - Content Providers

Yamba Part 4

   Content Provider Overview

Example of Content Provider

• Content Providers share content with applications across application boundaries.
• Examples of built-in Content Providers are:
  • Contacts
  • MediaStore
  • Settings and more.

   Typical Usage of Content Providers

Typical Usage of Content Providers

   Content Provider Lifecycle

Content Provider Lifecycle

• Content provider is initiated first time it is used via a call to onCreate().
• There is no callback for cleaning up after the provider.
• When modifying the data (insert/update/delete), open/close database atomically.
• When reading the data, leave database open or else the data will get garbage collected.

   Content Provider Template

package com.marakana.android.lifecycle;

import android.content.ContentProvider;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.util.Log;
import android.provider.Settings.System;

public class ProviderDemo extends ContentProvider {
  static final String TAG = "ProviderDemo";

  static final String AUTHORITY = "content://com.marakana.android.lifecycle.providerdemo";
  public static final Uri CONTENT_URI = Uri.parse(AUTHORITY);
  static final String SINGLE_RECORD_MIME_TYPE = "vnd.android.cursor.item/vnd.marakana.android.lifecycle.status";
  static final String MULTIPLE_RECORDS_MIME_TYPE = "vnd.android.cursor.dir/vnd.marakana.android.lifecycle.status";

  @Override
  public boolean onCreate() {
    Log.d(TAG, "onCreate");
    return true;
  }

  @Override
  public String getType(Uri uri) {
    String ret = getContext().getContentResolver().getType(System.CONTENT_URI);
    Log.d(TAG, "getType returning: " + ret);
    return ret;
  }

  @Override
  public Uri insert(Uri uri, ContentValues values) {
    Log.d(TAG, "insert uri: " + uri.toString());
    return null;
  }

  @Override
  public int update(Uri uri, ContentValues values, String selection,
      String[] selectionArgs) {
    Log.d(TAG, "update uri: " + uri.toString());
    return 0;
  }

  @Override
  public int delete(Uri uri, String selection, String[] selectionArgs) {
    Log.d(TAG, "delete uri: " + uri.toString());
    return 0;
  }

  @Override
  public Cursor query(Uri uri, String[] projection, String selection,
      String[] selectionArgs, String sortOrder) {
    Log.d(TAG, "query with uri: " + uri.toString());
    return null;
  }

}

   Content Provider Callbacks

   Registering Content Provider

...
<provider
     android:name=".ProviderDemo"
     android:authorities="com.marakana.android.lifecycle.providerdemo" />
...

The authority of this provider must match the uri authority that this provider is responding to.

   Part 5 - Lists and Adapters

Yamba Part 5

   Lists and Adapters Overview

Lists and Adapters Overview

Adapters connect potentially large data sets to small views

   Fragments

Fragments

   So, What’s a Fragment?

A fragment is a class implementing a portion of an activity.

• A fragment represents a particular operation or interface running within a larger activity.
• Fragments enable more modular activity design, making it easier to adapt an application to different screen orientations and multiple screen sizes.
• Fragments must be embedded in activities; they cannot run independent of activities.
• Most fragments define their own layout of views that live within the activity’s view hierarchy.
  • However, a fragment can implement a behavior that has no user interface component.
• A fragment has its own lifecycle, closely related to the lifecycle of its host activity.
• A fragment can be a static part of an activity, instantiated automatically during the activity’s creation.
• Or, you can create, add, and remove fragments dynamically in an activity at run-time.

   Loaders

Loaders make it easy to load data asynchronously in an activity or fragment. Loaders have these characteristics:

• They are available to every Activity and Fragment.
• They provide asynchronous loading of data.
• They monitor the source of their data and deliver new results when the content changes.
• They automatically reconnect to the last loader’s cursor when being recreated after a configuration change. Thus, they don’t need to re-query their data.

Loaders were introduced in Honeycomb (API 11).

• The Android Support Package includes support for loaders. By including the support package in your application, you can use loaders even if your application for a minSdkVersion of 4 or later.

   Using Loaders in an Application

An application that uses loaders typically includes the following:

• An Activity or Fragment.
• An instance of the LoaderManager.
• A CursorLoader to load data backed by a ContentProvider. Alternatively, you can implement your own subclass of Loader or AsyncTaskLoader to load data from some other source.
• A data source, such as a ContentProvider, when using a CursorLoader.
• An implementation for LoaderManager.LoaderCallbacks. This is where you create new loader instances and manage your references to existing loaders.
• A way of displaying the loader’s data, such as a SimpleCursorAdapter.

   Availability of Fragments and Loaders

   Part 6 - Broadcast Receivers

Yamba Part 6

   Broadcast Receiver Overview

Broadcast Receiver Lifecycle

• An Intent-based publish-subscribe mechanism.
• Great for listening system events such as SMS messages.

   Broadcast Receiver Template

package com.marakana.android.lifecycle;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;

public class ReceiverDemo extends BroadcastReceiver {
  static final String TAG = "ReceiverDemo";

  @Override
  public void onReceive(Context context, Intent intent) {
    Log.d(TAG, "onReceive action: "+intent.getAction() );
  }

}

   Receiver Lifecycle Explained

D/ReceiverDemo( 7964): onReceive action: marakana.intent.action.ReceiverDemo

   Broadcast Receiver Callbacks

   Registering Broadcast Receiver

<receiver android:name=".ReceiverDemo">
  <intent-filter>
    <action android:name="marakana.intent.action.ReceiverDemo" />
  </intent-filter>
</receiver>

...
@Override
protected void onCreate(Bundle savedInstanceState) {
  super.onCreate(savedInstanceState);
  ...
  // Create the receiver
  receiver = new TimelineReceiver();
  filter = new IntentFilter( UpdaterService.NEW_STATUS_INTENT );
}

protected void onResume() {
  super.onResume();
  super.registerReceiver(receiver, filter,
      "com.marakana.yamba.SEND_TIMELINE_NOTIFICATIONS", null);
}

@Override
protected void onPause() {
  super.onPause();
  unregisterReceiver(receiver);
}
...

   Part 7 - App Widgets

Yamba Part 7

   App Widgets Overview

• App widgets are miniature views that can live in other apps, such as Home app.
• They are a special implementation of Broadcast Receivers.

<receiver
    android:name=".YambaWidget"
    android:label="@string/app_name" >
    <intent-filter>
        <action android:name="com.marakana.broadcast.NEW_STATUS" />
    </intent-filter>

    <intent-filter>
        <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
    </intent-filter>
    <meta-data
        android:name="android.appwidget.provider"
        android:resource="@xml/widget" />
</receiver>

<?xml version="1.0" encoding="utf-8"?>
<appwidget-provider xmlns:android="http://schemas.android.com/apk/res/android"
    android:minHeight="72dp"
    android:minWidth="294dp"
    android:updatePeriodMillis="10000" >
</appwidget-provider>

   Implementing App Widget

package com.marakana.android.yamba;

...

public class YambaWidget extends AppWidgetProvider {
        private static final String TAG = YambaWidget.class.getSimpleName();

        @Override
        public void onReceive(Context context, Intent intent) {
                super.onReceive(context, intent);
                if (intent.getAction().equals(YambaApp.NEW_STATUS_BROADCAST)) {
                        AppWidgetManager appWidgetManager = AppWidgetManager
                                        .getInstance(context);
                        this.onUpdate(context, appWidgetManager, appWidgetManager
                                        .getAppWidgetIds(new ComponentName(context,
                                                        YambaWidget.class)));
                        Log.d(TAG, "onReceived");
                }
        }

        @Override
        public void onUpdate(Context context, AppWidgetManager appWidgetManager,
                        int[] appWidgetIds) {
                super.onUpdate(context, appWidgetManager, appWidgetIds);

                // Get the data
                Cursor cursor = context.getContentResolver().query(
                                StatusProvider.CONTENT_URI, null, null, null,
                                StatusData.SORT_BY);

                // Do we have any data?
                if (cursor!=null && cursor.moveToFirst()) {
                        String user = cursor.getString(cursor
                                        .getColumnIndex(StatusData.C_USER));
                        String text = cursor.getString(cursor
                                        .getColumnIndex(StatusData.C_TEXT));

                        // Loop thru all the widget instances
                        for (int appWidgetId : appWidgetIds) {
                                RemoteViews views = new RemoteViews(context.getPackageName(),
                                                R.layout.row);
                                views.setTextViewText(R.id.text_user, user);
                                views.setTextViewText(R.id.text_text, text);
                                views.setTextViewText(R.id.text_createdAt, "");
                                appWidgetManager.updateAppWidget(appWidgetId, views);
                        }
                }
                Log.d(TAG, "onUpdated");
        }

}

   Yamba App Widget Output

Yamba App Widget Output

   Quiz

1. Name four main Android app building blocks.

2. What is an activity?

3. Name major callback methods of an activity.

4. What is a service?

5. Name major callback methods of a service.

6. What is a broadcast receiver?

7. Name major callback methods of a broadcast receiver.

8. What is a content provider?

9. Name major callback methods of a content provider.

10. What does an Android app consist of?

   Architecting Android Apps Summary

This module was an introduction to main components that make up an app. By now, you should know of activities, services, providers and receivers as well as intents and other major components of an app.

Debugging Android Apps

   Objectives of Android Debugging

This module provides an overview of some of the tools available in Android SDK that can help you with debugging your apps. By the end of this module you should have a general knowledge of what is available and how to use it.

The tools we’ll explore include:

• Logcat
• Debugger
• Traceview
• HierarchyViewer

   LogCat

LogCat

The universal, most versatile way to track what is going on in your app.

Can be viewed via command line or Eclipse.

Logs can be generated both from SDK Java code, or low-level C code via Bionic libc extension.

   Debugger

Debugger

Your standard debugger is included in SDK, with all the usual bells & whistles.

   Traceview

Traceview

Traceview helps you profile you application and find bottlenecks. It shows execution of various calls through the entire stack. You can zoom into specific calls.

   HierarchyViewer

HierarchyViewer

Hierarchy Viewer helps you analyze your User Interface.

Base UI tends to be the most “expensive” part of your application, this tool is very useful.

   Quiz

1. What is the global logging framework in Android?

2. What criteria can you filter the logs for?

3. How do you debug Android apps?

4. What is the tool for profiling the execution of your code?

5. How do you profile your UI?

   Summary of Android Debugging

In this module, you learned about some of the SDK tools, such as Logcat, Debugger, Traceview, and HierarchyViewer. You should be able to identify which one to use in what situation.

Android Security

   Objectives of Android Security

The goal of this module is to provide high level overview of how Android security is architected. By the end of this module, you should know how apps are sandboxed and how kernel enforces security rights. Topics covered include:

• Security design overview
• Application sandboxing
• Using permissions
• Declaring permissions

   Security Overview

No app can adversely impact other apps, user, or OS

• Cannot read/write user’s private data
• Cannot read other app’s data
• Cannot perform network access
• Cannot keep device awake, and so on

Each application is its own sandbox:

• To share resources, apps need to request permissions
• User must grant permissions at install time

Linux manages security:

• Not up to Dalvik (Java) but outsourced to Linux
• Native code (NDK) also adheres to sandboxing

   Application Sandboxing

Sandboxing

An application is an island on its own.

It contains any number of Activities, Services, Receivers and Providers.

It has its own file system, database, place to store native libraries.

No other app can access any of its data without prior permission.

   Permissions

Permissions

A component that does something potentially dangerous can require callers to have permission to access it.

App that wants to use it must have user grant it permission.

Permissions are granted at install time. All or nothing. Forever.

   Quiz

1. What is the main premise of Android security?

2. Who enforces the sandboxing?

3. What if apps what to connect to one another?

4. What are the permission levels?

   Summary of Android Security

This module was a high level overview of how security in Android works. You show know that Linux kernel is the sole enforcer of the security rights, and that each app in Android runs in its own process.

Summary of Android Overview

The goal of this module was to introduce you to Android platform. By now, you should know a bit about:

• Android History
• Various parts of Android Stack
• Tools for developing Android apps
• Main Android app building blocks
• How to architect a simple application
• Overview of how Android UI is structured
• Debugging and testing Android apps
• Design of Android security system